/**
 * WhatsApp User ID 查找脚本
 * 在页面上下文中执行，查找当前登录的WhatsApp用户ID
 * 在每次页面刷新时自动执行检查
 */

// 立即执行函数，避免污染全局作用域
(function() {
    console.log('WhatsApp User ID 查找脚本已加载');
    
    // 获取脚本的requestId参数
    const scriptElement = document.currentScript;
    const requestId = scriptElement?.getAttribute('data-request-id') || '';
    
    console.log(`开始查找WhatsApp用户ID (requestId: ${requestId})...`);
    
    // 在这里实现用户ID查找逻辑
    function findUserId() {
        let foundUserId = null;
        
        // 广度优先搜索所有React根元素
        function searchAllReactRoots() {
            // 尝试多个可能的元素
            const possibleRoots = [
                ...document.querySelectorAll('#app, #main, #side'),
                ...document.querySelectorAll('div[role="listitem"]'),
                ...document.querySelectorAll('div[data-id]'),
                ...document.querySelectorAll('header')
            ];
            
            console.log(`找到 ${possibleRoots.length} 个可能的React根元素`);
            
            // 遍历所有可能的根元素
            for (const root of possibleRoots) {
                try {
                    // 查找所有React相关属性
                    const reactKeys = Object.keys(root).filter(key => 
                        key.startsWith('__react') || key.includes('react')
                    );
                    
                    for (const key of reactKeys) {
                        const fiber = root[key];
                        if (!fiber) continue;
                        
                        // 广度优先搜索Fiber树
                        searchFiberTree(fiber);
                        if (foundUserId) return foundUserId;
                    }
                } catch (e) {
                    // 忽略错误
                }
            }
            
            return null;
        }
        
        // 广度优先搜索Fiber树
        function searchFiberTree(fiber) {
            if (!fiber || typeof fiber !== 'object') return;
            
            // 使用队列实现广度优先搜索
            const queue = [{ node: fiber, path: 'root' }];
            const visited = new Set();
            
            while (queue.length > 0 && !foundUserId) {
                const { node, path } = queue.shift();
                
                // 防止循环引用
                if (visited.has(node)) continue;
                visited.add(node);
                
                // 检查当前节点是否包含目标属性
                checkNodeForUserId(node, path);
                if (foundUserId) break;
                
                // 添加子节点到队列
                if (node.child) {
                    queue.push({ node: node.child, path: `${path}.child` });
                }
                
                if (node.sibling) {
                    queue.push({ node: node.sibling, path: `${path}.sibling` });
                }
                
                if (node.memoizedProps) {
                    queue.push({ node: node.memoizedProps, path: `${path}.memoizedProps` });
                }
                
                if (node.stateNode && typeof node.stateNode === 'object') {
                    queue.push({ node: node.stateNode, path: `${path}.stateNode` });
                }
                
                // 检查其他可能的属性
                const otherKeys = ['props', 'state', 'memoizedState', 'pendingProps', 'chats', 'msgs'];
                for (const key of otherKeys) {
                    if (node[key] && typeof node[key] === 'object') {
                        queue.push({ node: node[key], path: `${path}.${key}` });
                    }
                }
            }
        }
        
        // 检查单个节点是否包含用户ID
        function checkNodeForUserId(node, path) {
            try {
                // 直接检查__x_originalSelfAuthor
                if (node.__x_originalSelfAuthor && node.__x_originalSelfAuthor._serialized) {
                    console.log(`✅ 在路径 ${path} 找到 __x_originalSelfAuthor!`);
                    foundUserId = node.__x_originalSelfAuthor._serialized;
                    return true;
                }
                
                // 检查是否有我的联系人标识
                if (node.__x_me === true && node.__x_id && node.__x_id._serialized) {
                    console.log(`✅ 在路径 ${path} 找到 __x_me 联系人!`);
                    foundUserId = node.__x_id._serialized;
                    return true;
                }
                
                // 检查所有子属性
                for (const key in node) {
                    try {
                        if (key === 'parent' || key === 'return') continue;
                        
                        const value = node[key];
                        if (value && typeof value === 'object') {
                            // 检查子对象是否包含 __x_originalSelfAuthor
                            if (value.__x_originalSelfAuthor && value.__x_originalSelfAuthor._serialized) {
                                console.log(`✅ 在路径 ${path}.${key} 找到 __x_originalSelfAuthor!`);
                                foundUserId = value.__x_originalSelfAuthor._serialized;
                                return true;
                            }
                            
                            // 检查子对象是否是我的联系人
                            if (value.__x_me === true && value.__x_id && value.__x_id._serialized) {
                                console.log(`✅ 在路径 ${path}.${key} 找到 __x_me 联系人!`);
                                foundUserId = value.__x_id._serialized;
                                return true;
                            }
                        }
                    } catch (e) {
                        // 忽略属性访问错误
                    }
                }
            } catch (e) {
                // 忽略节点检查错误
            }
            
            return false;
        }
        
        // 备用方法：寻找自己发送的消息
        function findUserIdFromMessages() {
            // 找到所有消息元素
            const messages = document.querySelectorAll('[data-id]');
            console.log(`找到 ${messages.length} 个消息元素`);
            
            for (const msg of messages) {
                try {
                    const dataId = msg.getAttribute('data-id');
                    if (!dataId) continue;
                    
                    // 自己发送的消息: true_CHATID_MSGID
                    if (dataId.startsWith('true_')) {
                        const parts = dataId.split('_');
                        if (parts.length >= 3) {
                            // CHATID通常是对方的ID，但我们可以找到消息对象
                            const fiberKey = Object.keys(msg).find(key => key.startsWith('__reactFiber$'));
                            if (!fiberKey) continue;
                            
                            const fiber = msg[fiberKey];
                            searchFiberTree(fiber);
                            if (foundUserId) return foundUserId;
                        }
                    }
                } catch (e) {
                    // 忽略错误
                }
            }
            
            return null;
        }
        
        // 执行搜索
        console.log('开始在页面上下文搜索React树...');
        foundUserId = searchAllReactRoots();
        
        // 如果仍然没找到，尝试从消息获取
        if (!foundUserId) {
            console.log('没有在React树中找到用户ID，尝试分析消息元素...');
            foundUserId = findUserIdFromMessages();
        }
        
        // 返回结果
        return foundUserId;
    }
    
    // 执行用户ID查找并发送结果的函数
    function executeAndSendResult() {
        // 尝试查找用户ID
        const userId = findUserId();
        
        // 将结果发送回内容脚本
        window.postMessage({
            type: 'FROM_WHATSAPP_PAGE_CONTEXT',
            action: 'getUserId',
            requestId: requestId,
            userId: userId
        }, '*');
        
        console.log(`用户ID查找完成，结果: ${userId || '未找到'}`);
        
        return userId;
    }
    
    // 尝试在页面加载完成后立即执行
    let checkAttempts = 0;
    const maxAttempts = 10;
    
    // 页面加载完成后执行检查
    function checkWhenReady() {
        // WhatsApp Web加载的标志元素
        const appLoaded = document.querySelector('#app, #main, .app');
        checkAttempts++;
        
        if (appLoaded || checkAttempts >= maxAttempts) {
            console.log(`WhatsApp界面已加载，执行用户ID检查 (尝试次数: ${checkAttempts})`);
            setTimeout(executeAndSendResult, 1000); // 延迟1秒确保React组件已完全加载
        } else {
            console.log(`等待WhatsApp界面加载... (尝试: ${checkAttempts}/${maxAttempts})`);
            setTimeout(checkWhenReady, 1000); // 每秒检查一次
        }
    }
    
    // 当DOM内容加载完成后开始检查
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', checkWhenReady);
    } else {
        checkWhenReady();
    }
    
    // 同时使用MutationObserver监听DOM变化，以确保在WhatsApp应用加载后执行检查
    const appObserver = new MutationObserver((mutations) => {
        // 检查是否有主要WhatsApp元素被添加
        const whatsappLoaded = document.querySelector('#app, #side, #main');
        if (whatsappLoaded) {
            console.log('检测到WhatsApp界面加载完成，准备执行用户ID检查');
            setTimeout(executeAndSendResult, 2000); // 延迟2秒确保React完全初始化
            appObserver.disconnect(); // 停止观察
        }
    });
    
    // 开始观察document.body的子节点变化
    if (document.body) {
        appObserver.observe(document.body, { childList: true, subtree: true });
    } else {
        // 如果body还不存在，等待DOM加载后再观察
        document.addEventListener('DOMContentLoaded', () => {
            appObserver.observe(document.body, { childList: true, subtree: true });
        });
    }
})(); 